home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / DistUpgrade / DistUpgradeController.py < prev    next >
Text File  |  2009-11-02  |  78KB  |  1,645 lines
  1. # DistUpgradeController.py 
  2. #  
  3. #  Copyright (c) 2004-2008 Canonical
  4. #  
  5. #  Author: Michael Vogt <michael.vogt@ubuntu.com>
  6. # 
  7. #  This program is free software; you can redistribute it and/or 
  8. #  modify it under the terms of the GNU General Public License as 
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. # 
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. # 
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21.  
  22.  
  23. import warnings
  24. warnings.filterwarnings("ignore", "apt API not stable yet", FutureWarning)
  25. import apt
  26. import apt_pkg
  27. import sys
  28. import os
  29. import subprocess
  30. import logging
  31. import re
  32. import statvfs
  33. import shutil
  34. import glob
  35. import time
  36. import copy
  37. import ConfigParser
  38. from stat import *
  39. from utils import country_mirror, url_downloadable, check_and_fix_xbit
  40. from string import Template
  41.  
  42.  
  43. import DistUpgradeView
  44. from DistUpgradeConfigParser import DistUpgradeConfig
  45. from DistUpgradeFetcherCore import country_mirror
  46. from DistUpgradeQuirks import DistUpgradeQuirks
  47. from DistUpgradeAptCdrom import AptCdrom
  48. from DistUpgradeAufs import setupAufs, aufsOptionsAndEnvironmentSetup
  49.  
  50. from sourceslist import SourcesList, SourceEntry, is_mirror
  51. from distro import Distribution, get_distro, NoDistroTemplateException
  52.  
  53. from DistUpgradeGettext import gettext as _
  54. from DistUpgradeGettext import ngettext
  55. import gettext
  56.  
  57. from DistUpgradeCache import *
  58. from DistUpgradeApport import *
  59.  
  60.  
  61. class NoBackportsFoundException(Exception):
  62.     pass
  63.  
  64.  
  65. class DistUpgradeController(object):
  66.     """ this is the controller that does most of the work """
  67.     
  68.     def __init__(self, distUpgradeView, options=None, datadir=None):
  69.         # setup the paths
  70.         localedir = "/usr/share/locale/"
  71.         if datadir == None:
  72.             datadir = os.getcwd()
  73.             localedir = os.path.join(datadir,"mo")
  74.             gladedir = datadir
  75.         self.datadir = datadir
  76.         self.options = options
  77.  
  78.         # init gettext
  79.         gettext.bindtextdomain("update-manager",localedir)
  80.         gettext.textdomain("update-manager")
  81.  
  82.         # setup the view
  83.         logging.debug("Using '%s' view" % distUpgradeView.__class__.__name__)
  84.         self._view = distUpgradeView
  85.         self._view.updateStatus(_("Reading cache"))
  86.         self.cache = None
  87.  
  88.         if not self.options or self.options.withNetwork == None:
  89.             self.useNetwork = True
  90.         else:
  91.             self.useNetwork = self.options.withNetwork
  92.         if options:
  93.             cdrompath = options.cdromPath
  94.         else:
  95.             cdrompath = None
  96.         self.aptcdrom = AptCdrom(distUpgradeView, cdrompath)
  97.  
  98.         # the configuration
  99.         self.config = DistUpgradeConfig(datadir)
  100.         self.sources_backup_ext = "."+self.config.get("Files","BackupExt")
  101.  
  102.         # move some of the options stuff into the self.config, 
  103.         # ConfigParser deals only with strings it seems *sigh*
  104.         self.config.add_section("Options")
  105.         self.config.set("Options","withNetwork", str(self.useNetwork))
  106.  
  107.         # aufs stuff
  108.         aufsOptionsAndEnvironmentSetup(self.options, self.config)
  109.  
  110.         # some constants here
  111.         self.fromDist = self.config.get("Sources","From")
  112.         self.toDist = self.config.get("Sources","To")
  113.         self.origin = self.config.get("Sources","ValidOrigin")
  114.         self.arch = apt_pkg.Config.Find("APT::Architecture")
  115.  
  116.         # we run with --force-overwrite by default
  117.         if not os.environ.has_key("RELEASE_UPGRADE_NO_FORCE_OVERWRITE"):
  118.             logging.debug("enable dpkg --force-overwrite")
  119.             apt_pkg.Config.Set("DPkg::Options::","--force-overwrite")
  120.  
  121.         # we run in full upgrade mode by default
  122.         self._partialUpgrade = False
  123.         
  124.         # install the quirks handler
  125.         self.quirks = DistUpgradeQuirks(self, self.config)
  126.  
  127.         # setup env var 
  128.         os.environ["RELEASE_UPGRADE_IN_PROGRESS"] = "1"
  129.         os.environ["PYCENTRAL_NO_DPKG_QUERY"] = "1"
  130.         os.environ["PYCENTRAL_FORCE_OVERWRITE"] = "1"
  131.         os.environ["PATH"] = "%s:%s" % (os.getcwd()+"/imported",
  132.                                         os.environ["PATH"])
  133.         check_and_fix_xbit("./imported/invoke-rc.d")
  134.  
  135.         # set max retries
  136.         maxRetries = self.config.getint("Network","MaxRetries")
  137.         apt_pkg.Config.Set("Acquire::Retries", str(maxRetries))
  138.         # max sizes for dpkgpm for large installs (see linux/limits.h and 
  139.         #                                          linux/binfmts.h)
  140.         apt_pkg.Config.Set("Dpkg::MaxArgs", str(64*1024))
  141.         apt_pkg.Config.Set("Dpkg::MaxArgBytes", str(128*1024))
  142.  
  143.         # smaller to avoid hangs
  144.         apt_pkg.Config.Set("Acquire::http::Timeout","20")
  145.         apt_pkg.Config.Set("Acquire::ftp::Timeout","20")
  146.  
  147.         # no list cleanup here otherwise a "cancel" in the upgrade
  148.         # will not restore the full state (lists will be missing)
  149.         apt_pkg.Config.Set("Apt::Get::List-Cleanup", "false")
  150.  
  151.         # forced obsoletes
  152.         self.forced_obsoletes = self.config.getlist("Distro","ForcedObsoletes")
  153.         # list of valid mirrors that we can add
  154.         self.valid_mirrors = self.config.getListFromFile("Sources","ValidMirrors")
  155.         # debugging
  156.         #apt_pkg.Config.Set("DPkg::Options::","--debug=0077")
  157.  
  158.         # apt cron job
  159.         self._aptCronJobPerms = 0755
  160.  
  161.     def openCache(self, lock=True):
  162.         logging.debug("openCache()")
  163.         if self.cache is not None:
  164.             self.cache.releaseLock()
  165.             self.cache.unlockListsDir()
  166.         try:
  167.             self.cache = MyCache(self.config,
  168.                                  self._view,
  169.                                  self.quirks,
  170.                                  self._view.getOpCacheProgress(),
  171.                                  lock)
  172.             # alias name for the plugin interface code
  173.             self.apt_cache = self.cache
  174.         # if we get a dpkg error that it was interrupted, just
  175.         # run dpkg --configure -a
  176.         except CacheExceptionDpkgInterrupted, e:
  177.             logging.warning("dpkg interrupted, calling dpkg --configure -a")
  178.             self._view.getTerminal().call(["dpkg","--configure","-a"])
  179.             self.cache = MyCache(self.config,
  180.                                  self._view,
  181.                                  self.quirks,
  182.                                  self._view.getOpCacheProgress())
  183.         except CacheExceptionLockingFailed, e:
  184.             logging.error("Cache can not be locked (%s)" % e)
  185.             self._view.error(_("Unable to get exclusive lock"),
  186.                              _("This usually means that another "
  187.                                "package management application "
  188.                                "(like apt-get or aptitude) "
  189.                                "already running. Please close that "
  190.                                "application first."));
  191.             sys.exit(1)
  192.         self.cache.partialUpgrade = self._partialUpgrade
  193.         logging.debug("/openCache(), new cache size %i" % len(self.cache))
  194.  
  195.     def _isRemoteLogin(self):
  196.         " check if we are running form a remote login "
  197.         # easy
  198.         if (os.environ.has_key("SSH_CONNECTION") or
  199.             os.environ.has_key("SSH_TTY")):
  200.             return True
  201.         # sudo cleans out SSH_ environment
  202.         out = subprocess.Popen(["who","-m","--ips"],stdout=subprocess.PIPE).communicate()[0]
  203.         logging.debug("who -m --ips: '%s'" % out)
  204.         # FIXME: what about IPv6 ?
  205.         # do regexp search for a IP 
  206.         if re.search("(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$", out):
  207.             return True
  208.         return False
  209.  
  210.     def _viewSupportsSSH(self):
  211.       """
  212.       Returns True if this view support upgrades over ssh.
  213.       In theory all views should support it, but for savety
  214.       we do only allow text ssh upgrades (see LP: #322482)
  215.       """
  216.       supported = self.config.getlist("View","SupportSSH")
  217.       if self._view.__class__.__name__ in supported:
  218.           return True
  219.       return False
  220.  
  221.     def _sshMagic(self):
  222.         """ this will check for server mode and if we run over ssh.
  223.             if this is the case, we will ask and spawn a additional
  224.             daemon (to be sure we have a spare one around in case
  225.             of trouble)
  226.         """
  227.         pidfile = os.path.join("/var/run/release-upgrader-sshd.pid")
  228.         if (not os.path.exists(pidfile) and self._isRemoteLogin()):
  229.             # check if the frontend supports ssh upgrades (see lp: #322482)
  230.             if not self._viewSupportsSSH():
  231.                 logging.error("upgrade over ssh not alllowed")
  232.                 self._view.error(_("Upgrading over remote connection not supported"),
  233.                                  _("You are running the upgrade over a "
  234.                                    "remote ssh connection with a frontend "
  235.                                    "that does "
  236.                                    "not support this. The upgrade will "
  237.                                    "abort now. Please try without ssh.")
  238.                                  )
  239.                 sys.exit(1)
  240.                 return False
  241.             # ask for a spare one to start
  242.             port = 9004
  243.             res = self._view.askYesNoQuestion(
  244.                 _("Continue running under SSH?"),
  245.                 _("This session appears to be running under ssh. "
  246.                   "It is not recommended to perform a upgrade "
  247.                   "over ssh currently because in case of failure "
  248.                 "it is harder to recover.\n\n"
  249.                   "If you continue, a additional ssh daemon will be "
  250.                   "started at port '%s'.\n"
  251.                   "Do you want to continue?") % port)
  252.             # abort
  253.             if res == False:
  254.                 sys.exit(1)
  255.             res = subprocess.call(["/usr/sbin/sshd",
  256.                                    "-o", "PidFile=%s" % pidfile,
  257.                                    "-p",str(port)])
  258.             if res == 0:
  259.                 self._view.information(
  260.                     _("Starting additional sshd"),
  261.                     _("To make recovery in case of failure easier, an "
  262.                       "additional sshd will be started on port '%s'. "
  263.                       "If anything goes wrong with the running ssh "
  264.                       "you can still connect to the additional one.\n"
  265.                       ) % port)
  266.         return True
  267.  
  268.     def _tryUpdateSelf(self):
  269.         """ this is a helper that is run if we are started from a CD
  270.             and we have network - we will then try to fetch a update
  271.             of ourself
  272.         """  
  273.         from MetaRelease import MetaReleaseCore
  274.         from DistUpgradeFetcherSelf import DistUpgradeFetcherSelf
  275.         # check if we run from a LTS 
  276.         forceLTS=False
  277.         if (self.release == "dapper" or
  278.             self.release == "hardy"):
  279.             forceLTS=True
  280.         m = MetaReleaseCore(useDevelopmentRelease=False,
  281.                             forceLTS=forceLTS)
  282.         # this will timeout eventually
  283.         while m.downloading:
  284.             self._view.processEvents()
  285.             time.sleep(0.1)
  286.         if m.new_dist is None:
  287.             logging.error("No new dist found")
  288.             return False
  289.         # we have a new dist
  290.         progress = self._view.getFetchProgress()
  291.         fetcher = DistUpgradeFetcherSelf(new_dist=m.new_dist,
  292.                                          progress=progress,
  293.                                          options=self.options,
  294.                                          view=self._view)
  295.         fetcher.run()
  296.  
  297.     def _pythonSymlinkCheck(self):
  298.         """ sanity check that /usr/bin/python points to the default
  299.             python version. Users tend to modify this symlink, which
  300.             breaks stuff in obscure ways (Ubuntu #75557).
  301.         """
  302.         logging.debug("_pythonSymlinkCheck run")
  303.         from ConfigParser import SafeConfigParser, NoOptionError
  304.         if os.path.exists('/usr/share/python/debian_defaults'):
  305.             config = SafeConfigParser()
  306.             config.readfp(file('/usr/share/python/debian_defaults'))
  307.             try:
  308.                 expected_default = config.get('DEFAULT', 'default-version')
  309.             except NoOptionError:
  310.                 logging.debug("no default version for python found in '%s'" % config)
  311.                 return False
  312.             try:
  313.                 fs_default_version = os.readlink('/usr/bin/python')
  314.             except OSError, e:
  315.                 logging.error("os.readlink failed (%s)" % e)
  316.                 return False
  317.             if not fs_default_version in (expected_default, os.path.join('/usr/bin', expected_default)):
  318.                 logging.debug("python symlink points to: '%s', but expected is '%s' or '%s'" % (fs_default_version, expected_default, os.path.join('/usr/bin', expected_default)))
  319.                 return False
  320.         return True
  321.  
  322.  
  323.     def prepare(self):
  324.         """ initial cache opening, sanity checking, network checking """
  325.         # first check if that is a good upgrade
  326.         self.release = release = subprocess.Popen(["lsb_release","-c","-s"],
  327.                                    stdout=subprocess.PIPE).communicate()[0].strip()
  328.         logging.debug("lsb-release: '%s'" % release)
  329.         if not (release == self.fromDist or release == self.toDist):
  330.             logging.error("Bad upgrade: '%s' != '%s' " % (release, self.fromDist))
  331.             self._view.error(_("Can not upgrade"),
  332.                              _("An upgrade from '%s' to '%s' is not "
  333.                                "supported with this tool." % (release, self.toDist)))
  334.             sys.exit(1)
  335.  
  336.         # setup aufs
  337.         if self.config.getWithDefault("Aufs", "EnableFullOverlay", False):
  338.             aufs_rw_dir = self.config.get("Aufs","RWDir")
  339.             if not setupAufs(aufs_rw_dir):
  340.                 logging.error("aufs setup failed")
  341.                 self._view.error(_("Sandbox setup failed"),
  342.                                  _("It was not possible to create the sandbox "
  343.                                    "environment."))
  344.                 return False
  345.  
  346.             # all good, tell the user about the sandbox mode
  347.             logging.info("running in aufs overlay mode")
  348.             self._view.information(_("Sandbox mode"),
  349.                                    _("This upgrade is running in sandbox "
  350.                                      "(test) mode. All changes are written "
  351.                                      "to '%s' and will be lost on the next "
  352.                                      "reboot.\n\n"
  353.                                      "*No* changes written to a systemdir "
  354.                                      "from now until the next reboot are "
  355.                                      "permanent.") % aufs_rw_dir)
  356.  
  357.         # setup backports (if we have them)
  358.         if self.options and self.options.havePrerequists:
  359.             backportsdir = os.getcwd()+"/backports"
  360.             logging.info("using backports in '%s' " % backportsdir)
  361.             logging.debug("have: %s" % glob.glob(backportsdir+"/*.udeb"))
  362.             if os.path.exists(backportsdir+"/usr/bin/dpkg"):
  363.                 apt_pkg.Config.Set("Dir::Bin::dpkg",backportsdir+"/usr/bin/dpkg");
  364.             if os.path.exists(backportsdir+"/usr/lib/apt/methods"):
  365.                 apt_pkg.Config.Set("Dir::Bin::methods",backportsdir+"/usr/lib/apt/methods")
  366.             conf = backportsdir+"/etc/apt/apt.conf.d/01ubuntu"
  367.             if os.path.exists(conf):
  368.                 logging.debug("adding config '%s'" % conf)
  369.                 apt_pkg.ReadConfigFile(apt_pkg.Config, conf)
  370.  
  371.         # do the ssh check and warn if we run under ssh
  372.         self._sshMagic()
  373.         # check python version
  374.         if not self._pythonSymlinkCheck():
  375.             logging.error("pythonSymlinkCheck() failed, aborting")
  376.             self._view.error(_("Can not upgrade"),
  377.                              _("Your python install is corrupted. "
  378.                                "Please fix the '/usr/bin/python' symlink."))
  379.             sys.exit(1)
  380.         # open cache
  381.         try:
  382.             self.openCache()
  383.         except SystemError, e:
  384.             logging.error("openCache() failed: '%s'" % e)
  385.             return False
  386.         if not self.cache.sanityCheck(self._view):
  387.             return False
  388.  
  389.         # now figure out if we need to go into desktop or 
  390.         # server mode - we use a heuristic for this
  391.         self.serverMode = self.cache.needServerMode()
  392.         if self.serverMode:
  393.             os.environ["RELEASE_UPGRADE_MODE"] = "server"
  394.         else:
  395.             os.environ["RELEASE_UPGRADE_MODE"] = "desktop"
  396.  
  397.         if not self.checkViewDepends():
  398.             logging.error("checkViewDepends() failed")
  399.             return False
  400.  
  401.         if os.path.exists("/usr/bin/debsig-verify"):
  402.             logging.error("debsig-verify is installed")
  403.             self._view.error(_("Package 'debsig-verify' is installed"),
  404.                              _("The upgrade can not continue with that "
  405.                                "package installed.\n"
  406.                                "Please remove it with synaptic "
  407.                                "or 'apt-get remove debsig-verify' first "
  408.                                "and run the upgrade again."))
  409.             self.abort()
  410.  
  411.         # FIXME: we may try to find out a bit more about the network
  412.         # connection here and ask more  intelligent questions
  413.         if self.aptcdrom and self.options and self.options.withNetwork == None:
  414.             res = self._view.askYesNoQuestion(_("Include latest updates from the Internet?"),
  415.                                               _("The upgrade system can use the internet to "
  416.                                                 "automatically download "
  417.                                                 "the latest updates and install them during the "
  418.                                                 "upgrade.  If you have a network connection this is "
  419.                                                 "highly recommended.\n\n"
  420.                                                 "The upgrade will take longer, but when "
  421.                                                 "it is complete, your system will be fully up to "
  422.                                                 "date.  You can choose not to do this, but you "
  423.                                                 "should install the latest updates soon after "
  424.                                                 "upgrading.\n"
  425.                                                 "If you answer 'no' here, the network is not "
  426.                                                 "used at all."),
  427.                                               'Yes')
  428.             self.useNetwork = res
  429.             self.config.set("Options","withNetwork", str(self.useNetwork))
  430.             logging.debug("useNetwork: '%s' (selected by user)" % res)
  431.             if res:
  432.                 self._tryUpdateSelf()
  433.         return True
  434.  
  435.     def _sourcesListEntryDownloadable(self, entry):
  436.         """
  437.         helper that checks if a sources.list entry points to 
  438.         something downloadable
  439.         """
  440.         logging.debug("verifySourcesListEntry: %s" % entry)
  441.         # no way to verify without network
  442.         if not self.useNetwork:
  443.             logging.debug("skiping downloadable check (no network)")
  444.             return True
  445.         # check if the entry points to something we can download
  446.         uri = "%s/dists/%s/Release" % (entry.uri, entry.dist)
  447.         return url_downloadable(uri, logging.debug)
  448.  
  449.     def rewriteSourcesList(self, mirror_check=True):
  450.         logging.debug("rewriteSourcesList()")
  451.  
  452.         sync_components = self.config.getlist("Sources","Components")
  453.  
  454.         # skip mirror check if special environment is set
  455.         # (useful for server admins with internal repos)
  456.         if (self.config.getWithDefault("Sources","AllowThirdParty",False) or
  457.             "RELEASE_UPRADER_ALLOW_THIRD_PARTY" in os.environ):
  458.             logging.warning("mirror check skipped, *overriden* via config")
  459.             mirror_check=False
  460.  
  461.         # check if we need to enable main
  462.         if mirror_check == True and self.useNetwork:
  463.             # now check if the base-meta pkgs are available in
  464.             # the archive or only available as "now"
  465.             # -> if not that means that "main" is missing and we
  466.             #    need to  enable it
  467.             for pkgname in self.config.getlist("Distro","BaseMetaPkgs"):
  468.                 if ((not self.cache.has_key(pkgname)
  469.                      or
  470.                      len(self.cache[pkgname].candidateOrigin) == 0)
  471.                     or
  472.                     (len(self.cache[pkgname].candidateOrigin) == 1 and
  473.                      self.cache[pkgname].candidateOrigin[0].archive == "now")
  474.                    ):
  475.                     logging.debug("BaseMetaPkg '%s' has no candidateOrigin" % pkgname)
  476.                     try:
  477.                         distro = get_distro()
  478.                         distro.get_sources(self.sources)
  479.                         distro.enable_component("main")
  480.                     except NoDistroTemplateException,e :
  481.                         # fallback if everything else does not work,
  482.                         # we replace the sources.list with a single
  483.                         # line to ubuntu-main
  484.                         logging.warning('get_distro().enable_component("man") failed, overwriting sources.list instead as last resort')
  485.                         s =  "# auto generated by update-manager"
  486.                         s += "deb http://archive.ubuntu.com/ubuntu %s main restricted" % self.toDist
  487.                         s += "deb http://archive.ubuntu.com/ubuntu %s-updates main restricted" % self.toDist
  488.                         s += "deb http://security.ubuntu.com/ubuntu %s-security main restricted" % self.toDist
  489.                         open("/etc/apt/sources.list","w").write(s)
  490.                     break
  491.             
  492.         # this must map, i.e. second in "from" must be the second in "to"
  493.         # (but they can be different, so in theory we could exchange
  494.         #  component names here)
  495.         fromDists = [self.fromDist,
  496.                      self.fromDist+"-security",
  497.                      self.fromDist+"-updates",
  498.                      self.fromDist+"-proposed",
  499.                      self.fromDist+"-backports"
  500.                     ]
  501.         toDists = [self.toDist,
  502.                    self.toDist+"-security",
  503.                    self.toDist+"-updates",
  504.                    self.toDist+"-proposed",
  505.                    self.toDist+"-backports"
  506.                    ]
  507.  
  508.         self.sources_disabled = False
  509.  
  510.         # look over the stuff we have
  511.         foundToDist = False
  512.         # collect information on what components (main,universe) are enabled for what distro (sub)version
  513.         # e.g. found_components = { 'hardy':set("main","restricted"), 'hardy-updates':set("main") }
  514.         found_components = {}
  515.         for entry in self.sources.list[:]:
  516.  
  517.             # ignore invalid records or disabled ones
  518.             if entry.invalid or entry.disabled:
  519.                 continue
  520.             
  521.             # we disable breezy cdrom sources to make sure that demoted
  522.             # packages are removed
  523.             if entry.uri.startswith("cdrom:") and entry.dist == self.fromDist:
  524.                 logging.debug("disabled '%s' cdrom entry (dist == fromDist)" % entry)
  525.                 entry.disabled = True
  526.                 continue
  527.             # check if there is actually a lists file for them available
  528.             # and disable them if not
  529.             elif entry.uri.startswith("cdrom:"):
  530.                 # 
  531.                 listdir = apt_pkg.Config.FindDir("Dir::State::lists")
  532.                 if not os.path.exists("%s/%s%s_%s_%s" % 
  533.                                       (listdir,
  534.                                        apt_pkg.URItoFileName(entry.uri),
  535.                                        "dists",
  536.                                        entry.dist,
  537.                                        "Release")):
  538.                     logging.warning("disabling cdrom source '%s' because it has no  Release file" % entry)
  539.                     entry.disabled = True
  540.                 continue
  541.  
  542.             # special case for archive.canonical.com that needs to
  543.             # be rewritten (for pre-gutsy upgrades)
  544.             cdist = "%s-commercial" % self.fromDist
  545.             if (not entry.disabled and
  546.                 entry.uri.startswith("http://archive.canonical.com") and
  547.                 entry.dist == cdist):
  548.                 entry.dist = self.toDist
  549.                 entry.comps = ["partner"]
  550.                 logging.debug("transitioned commercial to '%s' " % entry)
  551.                 continue
  552.  
  553.             # special case for landscape.canonical.com because they
  554.             # don't use a standard archive layout (gutsy->hardy)
  555.             if (not entry.disabled and
  556.                 entry.uri.startswith("http://landscape.canonical.com/packages/%s" % self.fromDist)):
  557.                 logging.debug("commenting landscape.canonical.com out")
  558.                 entry.disabled = True
  559.                 continue
  560.             
  561.             # handle upgrades from a EOL release and check if there
  562.             # is a supported release available
  563.             if (not entry.disabled and
  564.                 "old-releases.ubuntu.com/" in entry.uri):
  565.                 logging.debug("upgrade from old-releases.ubuntu.com detected")
  566.                 # test country mirror first, then archive.u.c
  567.                 for uri in ["http://%sarchive.ubuntu.com/ubuntu" % country_mirror(),
  568.                             "http://archive.ubuntu.com/ubuntu"]:
  569.                     test_entry = copy.copy(entry)
  570.                     test_entry.uri = uri
  571.                     test_entry.dist = self.toDist
  572.                     if self._sourcesListEntryDownloadable(test_entry):
  573.                         logging.info("transition from old-release.u.c to %s" % uri)
  574.                         entry.uri = uri
  575.                         break
  576.  
  577.             logging.debug("examining: '%s'" % entry)
  578.             # check if it's a mirror (or official site)
  579.             validMirror = self.isMirror(entry.uri)
  580.             if validMirror or not mirror_check:
  581.                 validMirror = True
  582.                 # disabled/security/commercial are special cases
  583.                 # we use validTo/foundToDist to figure out if we have a 
  584.                 # main archive mirror in the sources.list or if we 
  585.                 # need to add one
  586.                 validTo = True
  587.                 if (entry.disabled or
  588.                     entry.type == "deb-src" or
  589.                     "/security.ubuntu.com" in entry.uri or
  590.                     "/archive.canonical.com" in entry.uri):
  591.                     validTo = False
  592.                 if entry.dist in toDists:
  593.                     # so the self.sources.list is already set to the new
  594.                     # distro
  595.                     logging.debug("entry '%s' is already set to new dist" % entry)
  596.                     foundToDist |= validTo
  597.                 elif entry.dist in fromDists:
  598.                     foundToDist |= validTo
  599.                     entry.dist = toDists[fromDists.index(entry.dist)]
  600.                     logging.debug("entry '%s' updated to new dist" % entry)
  601.                 else:
  602.                     # disable all entries that are official but don't
  603.                     # point to either "to" or "from" dist
  604.                     entry.disabled = True
  605.                     self.sources_disabled = True
  606.                     logging.debug("entry '%s' was disabled (unknown dist)" % entry)
  607.  
  608.                 # if we make it to this point, we have a official mirror
  609.  
  610.                 # check if the arch is powerpc or sparc and if so, transition
  611.                 # to ports.ubuntu.com (powerpc got demoted in gutsy, sparc
  612.                 # in hardy)
  613.                 if (entry.type == "deb" and
  614.                     not "ports.ubuntu.com" in entry.uri and
  615.                     (self.arch == "powerpc" or self.arch == "sparc")):
  616.                     logging.debug("moving %s source entry to 'ports.ubuntu.com' " % self.arch)
  617.                     entry.uri = "http://ports.ubuntu.com/ubuntu-ports/"
  618.  
  619.                 # gather what components are enabled and are inconsitent
  620.                 for d in ["%s" % self.toDist,
  621.                           "%s-updates" % self.toDist,
  622.                           "%s-security" % self.toDist]:
  623.                     # create entry if needed, ignore disabled
  624.                     # entries and deb-src
  625.                     found_components.setdefault(d,set())
  626.                     if (not entry.disabled and entry.dist == d and
  627.                         entry.type == "deb"):
  628.                         for comp in entry.comps:
  629.                             # only sync components we know about
  630.                             if not comp in sync_components:
  631.                                 continue
  632.                             found_components[d].add(comp)
  633.                     
  634.             # disable anything that is not from a official mirror
  635.             if not validMirror:
  636.                 if entry.dist == self.fromDist:
  637.                     entry.dist = self.toDist
  638.                 entry.comment += " " + _("disabled on upgrade to %s") % self.toDist
  639.                 entry.disabled = True
  640.                 self.sources_disabled = True
  641.                 logging.debug("entry '%s' was disabled (unknown mirror)" % entry)
  642.  
  643.         # now go over the list again and check for missing components 
  644.         # in $dist-updates and $dist-security and add them
  645.         for entry in self.sources.list[:]:
  646.             # skip all comps that are not relevant (including e.g. "hardy")
  647.             if (entry.invalid or entry.disabled or entry.type == "deb-src" or 
  648.                 entry.uri.startswith("cdrom:") or entry.dist == self.toDist):
  649.                 continue
  650.             # now check for "$dist-updates" and "$dist-security" and add any inconsistencies
  651.             if found_components.has_key(entry.dist):
  652.                 # add the delta between "hardy" comps and "hardy-updates" comps once
  653.                 logging.info("fixing components inconsistency from '%s'" % entry)
  654.                 entry.comps.extend(list(found_components[self.toDist]-found_components[entry.dist]))
  655.                 logging.info("to new entry '%s'" % entry)
  656.                 del found_components[entry.dist]
  657.         return foundToDist
  658.  
  659.     def updateSourcesList(self):
  660.         logging.debug("updateSourcesList()")
  661.         self.sources = SourcesList(matcherPath=".")
  662.         if not self.rewriteSourcesList(mirror_check=True):
  663.             logging.error("No valid mirror found")
  664.             res = self._view.askYesNoQuestion(_("No valid mirror found"),
  665.                              _("While scanning your repository "
  666.                                "information no mirror entry for "
  667.                                "the upgrade was found. "
  668.                                "This can happen if you run a internal "
  669.                                "mirror or if the mirror information is "
  670.                                "out of date.\n\n"
  671.                                "Do you want to rewrite your "
  672.                                "'sources.list' file anyway? If you choose "
  673.                                "'Yes' here it will update all '%s' to '%s' "
  674.                                "entries.\n"
  675.                                "If you select 'No' the upgrade will cancel."
  676.                                ) % (self.fromDist, self.toDist))
  677.             if res:
  678.                 # re-init the sources and try again
  679.                 self.sources = SourcesList(matcherPath=".")
  680.                 # its ok if rewriteSourcesList fails here if
  681.                 # we do not use a network, the sources.list may be empty
  682.                 if (not self.rewriteSourcesList(mirror_check=False)
  683.                     and self.useNetwork):
  684.                     #hm, still nothing useful ...
  685.                     prim = _("Generate default sources?")
  686.                     secon = _("After scanning your 'sources.list' no "
  687.                               "valid entry for '%s' was found.\n\n"
  688.                               "Should default entries for '%s' be "
  689.                               "added? If you select 'No', the upgrade "
  690.                               "will cancel.") % (self.fromDist, self.toDist)
  691.                     if not self._view.askYesNoQuestion(prim, secon):
  692.                         self.abort()
  693.  
  694.                     # add some defaults here
  695.                     # FIXME: find mirror here
  696.                     logging.info("generate new default sources.list")
  697.                     uri = "http://archive.ubuntu.com/ubuntu"
  698.                     comps = ["main","restricted"]
  699.                     self.sources.add("deb", uri, self.toDist, comps)
  700.                     self.sources.add("deb", uri, self.toDist+"-updates", comps)
  701.                     self.sources.add("deb",
  702.                                      "http://security.ubuntu.com/ubuntu/",
  703.                                      self.toDist+"-security", comps)
  704.             else:
  705.                 self.abort()
  706.  
  707.         # write (well, backup first ;) !
  708.         self.sources.backup(self.sources_backup_ext)
  709.         self.sources.save()
  710.  
  711.         # re-check if the written self.sources are valid, if not revert and
  712.         # bail out
  713.         # TODO: check if some main packages are still available or if we
  714.         #       accidentally shot them, if not, maybe offer to write a standard
  715.         #       sources.list?
  716.         try:
  717.             sourceslist = apt_pkg.GetPkgSourceList()
  718.             sourceslist.ReadMainList()
  719.         except SystemError:
  720.             logging.error("Repository information invalid after updating (we broke it!)")
  721.             self._view.error(_("Repository information invalid"),
  722.                              _("Upgrading the repository information "
  723.                                "resulted in a invalid file. Please "
  724.                                "report this as a bug."))
  725.             return False
  726.  
  727.         if self.sources_disabled:
  728.             self._view.information(_("Third party sources disabled"),
  729.                              _("Some third party entries in your sources.list "
  730.                                "were disabled. You can re-enable them "
  731.                                "after the upgrade with the "
  732.                                "'software-properties' tool or "
  733.                                "your package manager."
  734.                                ))
  735.         return True
  736.  
  737.     def _logChanges(self):
  738.         # debugging output
  739.         logging.debug("About to apply the following changes")
  740.         inst = []
  741.         up = []
  742.         rm = []
  743.         held = []
  744.         keep = []
  745.         for pkg in self.cache:
  746.             if pkg.markedInstall: inst.append(pkg.name)
  747.             elif pkg.markedUpgrade: up.append(pkg.name)
  748.             elif pkg.markedDelete: rm.append(pkg.name)
  749.             elif (pkg.isInstalled and pkg.isUpgradable): held.append(pkg.name)
  750.             elif pkg.isInstalled and pkg.markedKeep: keep.append(pkg.name)
  751.         logging.debug("Keep at same version: %s" % " ".join(keep))
  752.         logging.debug("Upgradable, but held- back: %s" % " ".join(held))
  753.         logging.debug("Remove: %s" % " ".join(rm))
  754.         logging.debug("Install: %s" % " ".join(inst))
  755.         logging.debug("Upgrade: %s" % " ".join(up))
  756.         
  757.  
  758.     def doPostInitialUpdate(self):
  759.         # check if we have packages in ReqReinst state that are not
  760.         # downloadable
  761.         logging.debug("doPostInitialUpdate")
  762.         self.quirks.run("PostInitialUpdate")
  763.         if len(self.cache.reqReinstallPkgs) > 0:
  764.             logging.warning("packages in reqReinstall state, trying to fix")
  765.             self.cache.fixReqReinst(self._view)
  766.             self.openCache()
  767.         if len(self.cache.reqReinstallPkgs) > 0:
  768.             reqreinst = self.cache.reqReinstallPkgs
  769.             header = ngettext("Package in inconsistent state",
  770.                               "Packages in inconsistent state",
  771.                               len(reqreinst))
  772.             summary = ngettext("The package '%s' is in an inconsistent "
  773.                                "state and needs to be reinstalled, but "
  774.                                "no archive can be found for it. "
  775.                                "Please reinstall the package manually "
  776.                                "or remove it from the system.",
  777.                                "The packages '%s' are in an inconsistent "
  778.                                "state and need to be reinstalled, but "
  779.                                "no archive can be found for them. "
  780.                                "Please reinstall the packages manually "
  781.                                "or remove them from the system.",
  782.                                len(reqreinst)) % ", ".join(reqreinst)
  783.             self._view.error(header, summary)
  784.             return False
  785.         # FIXME: check out what packages are downloadable etc to
  786.         # compare the list after the update again
  787.         self.obsolete_pkgs = self.cache._getObsoletesPkgs()
  788.         self.foreign_pkgs = self.cache._getForeignPkgs(self.origin, self.fromDist, self.toDist)
  789.         if self.serverMode:
  790.             self.tasks = self.cache.installedTasks
  791.         logging.debug("Foreign: %s" % " ".join(self.foreign_pkgs))
  792.         logging.debug("Obsolete: %s" % " ".join(self.obsolete_pkgs))
  793.         return True
  794.  
  795.     def doUpdate(self, showErrors=True, forceRetries=None):
  796.         logging.debug("running doUpdate() (showErrors=%s)" % showErrors)
  797.         if not self.useNetwork:
  798.             logging.debug("doUpdate() will not use the network because self.useNetwork==false")
  799.             return True
  800.         self.cache._list.ReadMainList()
  801.         progress = self._view.getFetchProgress()
  802.         # FIXME: also remove all files from the lists partial dir!
  803.         currentRetry = 0
  804.         if forceRetries is not None:
  805.             maxRetries=forceRetries
  806.         else:
  807.             maxRetries = self.config.getint("Network","MaxRetries")
  808.         while currentRetry < maxRetries:
  809.             try:
  810.                 res = self.cache.update(progress)
  811.             except (SystemError, IOError), e:
  812.                 logging.error("IOError/SystemError in cache.update(): '%s'. Retrying (currentRetry: %s)" % (e,currentRetry))
  813.                 currentRetry += 1
  814.                 continue
  815.             # no exception, so all was fine, we are done
  816.             return True
  817.  
  818.         logging.error("doUpdate() failed completely")
  819.         if showErrors:
  820.             self._view.error(_("Error during update"),
  821.                              _("A problem occurred during the update. "
  822.                                "This is usually some sort of network "
  823.                                "problem, please check your network "
  824.                                "connection and retry."), "%s" % e)
  825.         return False
  826.  
  827.  
  828.     def _checkFreeSpace(self):
  829.         " this checks if we have enough free space on /var and /usr"
  830.         err_sum = _("Not enough free disk space")
  831.         err_long= _("The upgrade is now aborted. "
  832.                     "The upgrade needs a total of %s free space on disk '%s'. "
  833.                     "Please free at least an additional %s of disk "
  834.                     "space on '%s'. "
  835.                     "Empty your trash and remove temporary "
  836.                     "packages of former installations using "
  837.                     "'sudo apt-get clean'.")
  838.         # allow override
  839.         if self.config.getWithDefault("FreeSpace","SkipCheck",False):
  840.             logging.warning("free space check skipped via config override")
  841.             return True
  842.         # do the check
  843.         try:
  844.             self.cache.checkFreeSpace()
  845.         except NotEnoughFreeSpaceError, e:
  846.             # ok, showing multiple error dialog sucks from the UI
  847.             # perspective, but it means we do not need to break the
  848.             # string freeze
  849.             for required in e.free_space_required_list:
  850.                 self._view.error(err_sum, err_long % (required.size_total,
  851.                                                       required.dir,
  852.                                                       required.size_needed,
  853.                                                       required.dir))
  854.             return False
  855.         return True
  856.  
  857.  
  858.     def askDistUpgrade(self):
  859.         # check what packages got demoted and ask the user
  860.         # if those shall be removed
  861.         demotions = set()
  862.         demotions_file = self.config.get("Distro","Demotions")
  863.         if os.path.exists(demotions_file):
  864.             map(lambda pkgname: demotions.add(pkgname.strip()),
  865.                 filter(lambda line: not line.startswith("#"),
  866.                        open(demotions_file).readlines()))
  867.         self.installed_demotions = [pkg.name for pkg in self.cache if pkg.isInstalled and pkg.name in demotions]
  868.         if len(self.installed_demotions) > 0:
  869.         self.installed_demotions.sort()
  870.             logging.debug("demoted: '%s'" % " ".join(self.installed_demotions))
  871.             self._view.showDemotions(_("Support for some applications ended"),
  872.                                    _("Canonical Ltd. no longer provides "
  873.                                      "support for the following software "
  874.                                      "packages. You can still get support "
  875.                                      "from the community.\n\n"
  876.                                      "If you have not enabled community "
  877.                                      "maintained software (universe), "
  878.                                      "these packages will be suggested for "
  879.                                      "removal at the end of the upgrade."),
  880.                                      self.installed_demotions)
  881.             self._view.updateStatus(_("Calculating the changes"))
  882.         # FIXME: integrate this into main upgrade dialog!?!
  883.         if not self.cache.distUpgrade(self._view, self.serverMode, self._partialUpgrade):
  884.             return False
  885.  
  886.         if self.serverMode:
  887.             if not self.cache.installTasks(self.tasks):
  888.                 return False
  889.         changes = self.cache.getChanges()
  890.         # log the changes for debugging
  891.         self._logChanges()
  892.         # check if we have enough free space 
  893.         if not self._checkFreeSpace():
  894.             return False
  895.         # ask the user if he wants to do the changes
  896.         res = self._view.confirmChanges(_("Do you want to start the upgrade?"),
  897.                                         changes,
  898.                                         self.cache.requiredDownload)
  899.         return res
  900.  
  901.     def _disableAptCronJob(self):
  902.         if os.path.exists("/etc/cron.daily/apt"):
  903.             #self._aptCronJobPerms = os.stat("/etc/cron.daily/apt")[ST_MODE]
  904.             logging.debug("disabling apt cron job (%s)" % oct(self._aptCronJobPerms))
  905.             os.chmod("/etc/cron.daily/apt",0644)
  906.     def _enableAptCronJob(self):
  907.         if os.path.exists("/etc/cron.daily/apt"):
  908.             logging.debug("enabling apt cron job")
  909.             os.chmod("/etc/cron.daily/apt", self._aptCronJobPerms)
  910.  
  911.     def doDistUpgradeFetching(self):
  912.         # ensure that no apt cleanup is run during the download/install
  913.         self._disableAptCronJob()
  914.         # get the upgrade
  915.         currentRetry = 0
  916.         fprogress = self._view.getFetchProgress()
  917.         iprogress = self._view.getInstallProgress(self.cache)
  918.         # retry the fetching in case of errors
  919.         maxRetries = self.config.getint("Network","MaxRetries")
  920.         # FIXME: we get errors like 
  921.         #   "I wasn't able to locate file for the %s package" 
  922.         #  here sometimes. its unclear why and not reproducible, the 
  923.         #  current theory is that for some reason the file is not
  924.         #  considered trusted at the moment 
  925.         #  pkgAcquireArchive::QueueNext() runs debReleaseIndex::IsTrused()
  926.         #  (the later just checks for the existence of the .gpg file)
  927.         #  OR 
  928.         #  the fact that we get a pm and fetcher here confuses something
  929.         #  in libapt?
  930.         # POSSIBLE workaround: keep the list-dir locked so that 
  931.         #          no apt-get update can run outside from the release
  932.         #          upgrader 
  933.         user_canceled = False
  934.         while currentRetry < maxRetries:
  935.             try:
  936.                 pm = apt_pkg.GetPackageManager(self.cache._depcache)
  937.                 fetcher = apt_pkg.GetAcquire(fprogress)
  938.                 res = self.cache._fetchArchives(fetcher, pm)
  939.             except apt.cache.FetchCancelledException, e:
  940.                 logging.info("user canceled")
  941.                 user_canceled = True
  942.                 break
  943.             except IOError, e:
  944.                 # fetch failed, will be retried
  945.                 logging.error("IOError in cache.commit(): '%s'. Retrying (currentTry: %s)" % (e,currentRetry))
  946.                 currentRetry += 1
  947.                 continue
  948.             return True
  949.         
  950.         # maximum fetch-retries reached without a successful commit
  951.         if user_canceled:
  952.             self._view.information(_("Upgrade canceled"),
  953.                                    _("The upgrade cancels now and the original "
  954.                                      "system state is restored. You can resume "
  955.                                      "the upgrade at a later time."))
  956.         else:
  957.             logging.error("giving up on fetching after maximum retries")
  958.             self._view.error(_("Could not download the upgrades"),
  959.                              _("The upgrade is now aborted. Please check your "
  960.                                "Internet connection or "
  961.                                "installation media and try again. All files "
  962.                                "downloaded so far are kept."),
  963.                              "%s" % e)
  964.         # abort here because we want our sources.list back
  965.         self._enableAptCronJob()
  966.         self.abort()
  967.  
  968.     def enableApport(self, fname="/etc/default/apport"):
  969.         " enable apoprt "
  970.         # for jaunty and later we could use this instead:
  971.         #  env = copy.copy(os.environ)
  972.         #  env["force_start"] = "1"
  973.         #  subprocess.call(["/etc/init.d/apport","start"], env=env)
  974.         # but hardy and intrepid do not have the force_start yet
  975.         if not (os.path.exists(fname) and os.path.exists("etc-default-apport")):
  976.             return
  977.         # copy the jaunty version of the conf file in place
  978.         # (this avoids a conffile prompt later)
  979.         logging.debug("enabling apport")
  980.         shutil.copy("etc-default-apport","/etc/default/apport")
  981.         subprocess.call(["/etc/init.d/apport","start"])
  982.         
  983.     def doDistUpgrade(self):
  984.         # check if we want apport running during the upgrade
  985.         if self.config.getWithDefault("Distro","EnableApport", False):
  986.             self.enableApport()
  987.         # get the upgrade
  988.         currentRetry = 0
  989.         fprogress = self._view.getFetchProgress()
  990.         iprogress = self._view.getInstallProgress(self.cache)
  991.         # retry the fetching in case of errors
  992.         maxRetries = self.config.getint("Network","MaxRetries")
  993.         if not self._partialUpgrade:
  994.             self.quirks.run("StartUpgrade")
  995.         while currentRetry < maxRetries:
  996.             try:
  997.                 res = self.cache.commit(fprogress,iprogress)
  998.             except SystemError, e:
  999.                 logging.error("SystemError from cache.commit(): %s" % e)
  1000.                 # if its a ordering bug we can cleanly revert to
  1001.                 # the previous release, no packages have been installed
  1002.                 # yet (LP: #328655, #356781)
  1003.                 pre_configure_errors = [
  1004.                   "E:Internal Error, Could not perform immediate configuration",
  1005.                   "E:Couldn't configure pre-depend "]
  1006.                 for preconf_error in pre_configure_errors:
  1007.                     if str(e).startswith(preconf_error):
  1008.                         logging.debug("detected preconfigure error, restorting state")
  1009.                         self._enableAptCronJob()
  1010.                         # FIXME: strings are not good, but we are in string freeze
  1011.                         # currently
  1012.                         msg = _("Error during commit")
  1013.                         msg += "\n'%s'\n" % str(e)
  1014.                         msg += _("Restoring original system state")
  1015.                         self._view.error(_("Could not install the upgrades"), msg)
  1016.                         # abort() exits cleanly
  1017.                         self.abort()
  1018.                 
  1019.                 # invoke the frontend now and show a error message
  1020.                 msg = _("The upgrade is now aborted. Your system "
  1021.                         "could be in an unusable state. A recovery "
  1022.                         "will run now (dpkg --configure -a).")
  1023.                 if not self._partialUpgrade:
  1024.                     if not run_apport():
  1025.                         msg += _("\n\nPlease report this bug against the 'update-manager' "
  1026.                                  "package and include the files in /var/log/dist-upgrade/ "
  1027.                                  "in the bug report.\n"
  1028.                                  "%s" % e)
  1029.                 self._view.error(_("Could not install the upgrades"), msg)
  1030.                 # installing the packages failed, can't be retried
  1031.                 self._view.getTerminal().call(["dpkg","--configure","-a"])
  1032.                 self._enableAptCronJob()
  1033.                 return False
  1034.             except IOError, e:
  1035.                 # fetch failed, will be retried
  1036.                 logging.error("IOError in cache.commit(): '%s'. Retrying (currentTry: %s)" % (e,currentRetry))
  1037.                 currentRetry += 1
  1038.                 continue
  1039.             # no exception, so all was fine, we are done
  1040.             self._enableAptCronJob()
  1041.             return True
  1042.         
  1043.         # maximum fetch-retries reached without a successful commit
  1044.         logging.error("giving up on fetching after maximum retries")
  1045.         self._view.error(_("Could not download the upgrades"),
  1046.                          _("The upgrade is now aborted. Please check your "\
  1047.                            "Internet connection or "\
  1048.                            "installation media and try again. "),
  1049.                            "%s" % e)
  1050.         # abort here because we want our sources.list back
  1051.         self.abort()
  1052.  
  1053.     def doPostUpgrade(self):
  1054.         # reopen cache
  1055.         self.openCache()
  1056.         # run the quirks handler that does does like things adding
  1057.         # missing groups or similar work arounds, only do it on real
  1058.         # upgrades
  1059.         self.quirks.run("PostUpgrade")
  1060.         # check out what packages are cruft now
  1061.         # use self.{foreign,obsolete}_pkgs here and see what changed
  1062.         now_obsolete = self.cache._getObsoletesPkgs()
  1063.         now_foreign = self.cache._getForeignPkgs(self.origin, self.fromDist, self.toDist)
  1064.         logging.debug("Obsolete: %s" % " ".join(now_obsolete))
  1065.         logging.debug("Foreign: %s" % " ".join(now_foreign))
  1066.         # now sanity check - if a base meta package is in the obsolete list now, that means
  1067.         # that something went wrong (see #335154) badly with the network. this should never happen, but it did happen
  1068.         # at least once so we add extra paranoia here
  1069.         for pkg in self.config.getlist("Distro","BaseMetaPkgs"):
  1070.             if pkg in now_obsolete:
  1071.                 logging.error("the BaseMetaPkg '%s' is in the obsolete list, something is wrong, ignoring the obsoletes" % pkg)
  1072.                 now_obsolete = set()
  1073.                 break
  1074.         # check if we actually want obsolete removal
  1075.         if not self.config.getWithDefault("Distro","RemoveObsoletes", True):
  1076.             logging.debug("Skipping obsolete Removal")
  1077.             return True
  1078.  
  1079.         # now get the meta-pkg specific obsoletes and purges
  1080.         for pkg in self.config.getlist("Distro","MetaPkgs"):
  1081.             if self.cache.has_key(pkg) and self.cache[pkg].isInstalled:
  1082.                 self.forced_obsoletes.extend(self.config.getlist(pkg,"ForcedObsoletes"))
  1083.         # now add the obsolete kernels to the forced obsoletes
  1084.         self.forced_obsoletes.extend(self.cache.identifyObsoleteKernels())
  1085.         logging.debug("forced_obsoletes: %s", self.forced_obsoletes)
  1086.  
  1087.         # mark packages that are now obsolete (and where not obsolete
  1088.         # before) to be deleted. make sure to not delete any foreign
  1089.         # (that is, not from ubuntu) packages
  1090.         if self.useNetwork:
  1091.             # we can only do the obsoletes calculation here if we use a
  1092.             # network. otherwise after rewriting the sources.list everything
  1093.             # that is not on the CD becomes obsolete (not-downloadable)
  1094.             remove_candidates = now_obsolete - self.obsolete_pkgs
  1095.         else:
  1096.             # initial remove candidates when no network is used should
  1097.             # be the demotions to make sure we don't leave potential
  1098.             # unsupported software
  1099.             remove_candidates = set(self.installed_demotions)
  1100.         remove_candidates |= set(self.forced_obsoletes)
  1101.  
  1102.         # no go for the unused dependencies
  1103.         unused_dependencies = self.cache._getUnusedDependencies()
  1104.         logging.debug("Unused dependencies: %s" %" ".join(unused_dependencies))
  1105.         remove_candidates |= set(unused_dependencies)
  1106.  
  1107.         # see if we actually have to do anything here
  1108.         if not self.config.getWithDefault("Distro","RemoveObsoletes", True):
  1109.             logging.debug("Skipping RemoveObsoletes as stated in the config")
  1110.             remove_candidates = set()
  1111.         logging.debug("remove_candidates: '%s'" % remove_candidates)
  1112.         logging.debug("Start checking for obsolete pkgs")
  1113.         for pkgname in remove_candidates:
  1114.             if pkgname not in self.foreign_pkgs:
  1115.                 self._view.processEvents()
  1116.                 if not self.cache.tryMarkObsoleteForRemoval(pkgname, remove_candidates, self.foreign_pkgs):
  1117.                     logging.debug("'%s' scheduled for remove but not safe to remove, skipping", pkgname)
  1118.         logging.debug("Finish checking for obsolete pkgs")
  1119.  
  1120.         # get changes
  1121.         changes = self.cache.getChanges()
  1122.         logging.debug("The following packages are marked for removal: %s" % " ".join([pkg.name for pkg in changes]))
  1123.         summary = _("Remove obsolete packages?")
  1124.         actions = [_("_Keep"), _("_Remove")]
  1125.         # FIXME Add an explanation about what obsolete packages are
  1126.         #explanation = _("")
  1127.         if (len(changes) > 0 and 
  1128.             self._view.confirmChanges(summary, changes, 0, actions, False)):
  1129.             fprogress = self._view.getFetchProgress()
  1130.             iprogress = self._view.getInstallProgress(self.cache)
  1131.             try:
  1132.                 res = self.cache.commit(fprogress,iprogress)
  1133.             except (SystemError, IOError), e:
  1134.                 logging.error("cache.commit() in doPostUpgrade() failed: %s" % e)
  1135.                 self._view.error(_("Error during commit"),
  1136.                                  _("A problem occurred during the clean-up. "
  1137.                                    "Please see the below message for more "
  1138.                                    "information. "),
  1139.                                    "%s" % e)
  1140.         # run stuff after cleanup
  1141.         self.quirks.run("PostCleanup")
  1142.         # run the post upgrade scripts that can do fixup like xorg.conf
  1143.         # fixes etc - only do on real upgrades
  1144.         if not self._partialUpgrade:
  1145.             self.runPostInstallScripts()
  1146.         return True
  1147.  
  1148.     def runPostInstallScripts(self):
  1149.         """ 
  1150.         scripts that are run in any case after the distupgrade finished 
  1151.         whether or not it was successfull
  1152.         """
  1153.         # now run the post-upgrade fixup scripts (if any)
  1154.         for script in self.config.getlist("Distro","PostInstallScripts"):
  1155.             if not os.path.exists(script):
  1156.                 logging.warning("PostInstallScript: '%s' not found" % script)
  1157.                 continue
  1158.             logging.debug("Running PostInstallScript: '%s'" % script)
  1159.             try:
  1160.                 # work around kde tmpfile problem where it eats permissions
  1161.                 check_and_fix_xbit(script)
  1162.                 self._view.getTerminal().call([script], hidden=True)
  1163.             except Exception, e:
  1164.                 logging.error("got error from PostInstallScript %s (%s)" % (script, e))
  1165.         
  1166.     def abort(self):
  1167.         """ abort the upgrade, cleanup (as much as possible) """
  1168.         logging.debug("abort called")
  1169.         if hasattr(self, "sources"):
  1170.             self.sources.restoreBackup(self.sources_backup_ext)
  1171.         if hasattr(self, "aptcdrom"):
  1172.             self.aptcdrom.restoreBackup(self.sources_backup_ext)
  1173.         # generate a new cache
  1174.         self._view.updateStatus(_("Restoring original system state"))
  1175.         self._view.abort()
  1176.         self.openCache()
  1177.         sys.exit(1)
  1178.  
  1179.     def _checkDep(self, depstr):
  1180.         " check if a given depends can be satisfied "
  1181.         for or_group in apt_pkg.ParseDepends(depstr):
  1182.             logging.debug("checking: '%s' " % or_group)
  1183.             for dep in or_group:
  1184.                 depname = dep[0]
  1185.                 ver = dep[1]
  1186.                 oper = dep[2]
  1187.                 if not self.cache.has_key(depname):
  1188.                     logging.error("_checkDep: '%s' not in cache" % depname)
  1189.                     return False
  1190.                 inst = self.cache[depname]
  1191.                 instver = inst.installedVersion
  1192.                 if (instver != None and
  1193.                     apt_pkg.CheckDep(instver,oper,ver) == True):
  1194.                     return True
  1195.         logging.error("depends '%s' is not satisfied" % depstr)
  1196.         return False
  1197.                 
  1198.     def checkViewDepends(self):
  1199.         " check if depends are satisfied "
  1200.         logging.debug("checkViewDepends()")
  1201.         res = True
  1202.         # now check if anything from $foo-updates is required
  1203.         depends = self.config.getlist("View","Depends")
  1204.         depends.extend(self.config.getlist(self._view.__class__.__name__,
  1205.                                            "Depends"))
  1206.         for dep in depends:
  1207.             logging.debug("depends: '%s'", dep)
  1208.             res &= self._checkDep(dep)
  1209.             if not res:
  1210.                 # FIXME: instead of error out, fetch and install it
  1211.                 #        here
  1212.                 self._view.error(_("Required depends is not installed"),
  1213.                                  _("The required dependency '%s' is not "
  1214.                                    "installed. " % dep))
  1215.                 sys.exit(1)
  1216.         return res 
  1217.  
  1218.     def _verifyBackports(self):
  1219.         # run update (but ignore errors in case the countrymirror
  1220.         # substitution goes wrong, real errors will be caught later
  1221.         # when the cache is searched for the backport packages)
  1222.         backportslist = self.config.getlist("PreRequists","Packages")
  1223.         i=0
  1224.         noCache = apt_pkg.Config.Find("Acquire::http::No-Cache","false")
  1225.         maxRetries = self.config.getint("Network","MaxRetries")
  1226.         while i < maxRetries:
  1227.             self.doUpdate(showErrors=False)
  1228.             self.openCache()
  1229.             for pkgname in backportslist:
  1230.                 if not self.cache.has_key(pkgname):
  1231.                     logging.error("Can not find backport '%s'" % pkgname)
  1232.                     raise NoBackportsFoundException, pkgname
  1233.             if self._allBackportsAuthenticated(backportslist):
  1234.                 break
  1235.             # FIXME: move this to some more generic place
  1236.             logging.debug("setting a cache control header to turn off caching temporarily")
  1237.             apt_pkg.Config.Set("Acquire::http::No-Cache","true")
  1238.             i += 1
  1239.         if i == maxRetries:
  1240.             logging.error("pre-requists item is NOT trusted, giving up")
  1241.             return False
  1242.         apt_pkg.Config.Set("Acquire::http::No-Cache",noCache)
  1243.         return True
  1244.  
  1245.     def _allBackportsAuthenticated(self, backportslist):
  1246.         # check if the user overwrote the check
  1247.         if apt_pkg.Config.FindB("APT::Get::AllowUnauthenticated",False) == True:
  1248.             logging.warning("skip authentication check because of APT::Get::AllowUnauthenticated==true")
  1249.             return True
  1250.         try:
  1251.             b = self.config.getboolean("Distro","AllowUnauthenticated")
  1252.             if b:
  1253.                 return True
  1254.         except ConfigParser.NoOptionError, e:
  1255.             pass
  1256.         for pkgname in backportslist:
  1257.             pkg = self.cache[pkgname]                
  1258.             for cand in pkg.candidateOrigin:
  1259.                 if cand.trusted:
  1260.                     break
  1261.             else:
  1262.                 return False
  1263.         return True
  1264.  
  1265.     def isMirror(self, uri):
  1266.         " check if uri is a known mirror "
  1267.         uri = uri.rstrip("/")
  1268.         for mirror in self.valid_mirrors:
  1269.             mirror = mirror.rstrip("/")
  1270.             if is_mirror(mirror, uri):
  1271.                 return True
  1272.             # deal with mirrors like
  1273.             #    deb http://localhost:9977/security.ubuntu.com/ubuntu intrepid-security main restricted
  1274.             # both apt-debtorrent and apt-cacher use this (LP: #365537)
  1275.             mirror_host_part = mirror.split("//")[1]
  1276.             if uri.endswith(mirror_host_part):
  1277.                 logging.debug("found apt-cacher/apt-torrent style uri %s" % uri)
  1278.                 return True
  1279.         return False
  1280.  
  1281.     def _getPreReqMirrorLines(self, dumb=False):
  1282.         " get sources.list snippet lines for the current mirror "
  1283.         lines = ""
  1284.         sources = SourcesList(matcherPath=".")
  1285.         for entry in sources.list:
  1286.             if entry.invalid or entry.disabled:
  1287.                 continue
  1288.             if (entry.type == "deb" and 
  1289.                 self.isMirror(entry.uri) and
  1290.                 not entry.uri.startswith("http://security.ubuntu.com") and
  1291.                 not entry.uri.startswith("http://archive.ubuntu.com") ):
  1292.                 new_line = "deb %s %s-backports main/debian-installer\n" % (entry.uri, self.fromDist)
  1293.                 if not new_line in lines:
  1294.                     lines += new_line
  1295.             if (dumb and entry.type == "deb" and
  1296.                 "main" in entry.comps):
  1297.                 lines += "deb %s %s-backports main/debian-installer\n" % (entry.uri, self.fromDist)
  1298.         return lines
  1299.  
  1300.     def _addPreRequistsSourcesList(self, template, out, dumb=False):
  1301.         " add prerequists based on template into the path outfile "
  1302.         # go over the sources.list and try to find a valid mirror
  1303.         # that we can use to add the backports dir
  1304.         logging.debug("writing prerequists sources.list at: '%s' " % out)
  1305.         outfile = open(out, "w")
  1306.         mirrorlines = self._getPreReqMirrorLines(dumb)
  1307.         for line in open(template):
  1308.             template = Template(line)
  1309.             outline = template.safe_substitute(mirror=mirrorlines)
  1310.             outfile.write(outline)
  1311.             logging.debug("adding '%s' prerequists" % outline)
  1312.         outfile.close()
  1313.         return True
  1314.  
  1315.     def getRequiredBackports(self):
  1316.         " download the backports specified in DistUpgrade.cfg "
  1317.         logging.debug("getRequiredBackports()")
  1318.         res = True
  1319.         backportsdir = os.path.join(os.getcwd(),"backports")
  1320.         if not os.path.exists(backportsdir):
  1321.             os.mkdir(backportsdir)
  1322.         backportslist = self.config.getlist("PreRequists","Packages")
  1323.  
  1324.         # if we have them on the CD we are fine
  1325.         if self.aptcdrom and not self.useNetwork:
  1326.             logging.debug("Searching for pre-requists on CDROM")
  1327.             p = os.path.join(self.aptcdrom.cdrompath,
  1328.                              "dists/stable/main/dist-upgrader/binary-%s/" % apt_pkg.Config.Find("APT::Architecture"))
  1329.             found_pkgs = set()
  1330.             for udeb in glob.glob(p+"*_*.udeb"):
  1331.                 logging.debug("copying pre-req '%s' to '%s'" % (udeb, backportsdir))
  1332.                 found_pkgs.add(os.path.basename(udeb).split("_")[0])
  1333.                 shutil.copy(udeb, backportsdir)
  1334.             # now check if we got all backports on the CD
  1335.             if not set(backportslist) == found_pkgs:
  1336.                 logging.error("Expected backports: '%s' but got '%s'" % (set(backportslist), found_pkgs))
  1337.                 return False
  1338.             return self.setupRequiredBackports(backportsdir)
  1339.  
  1340.         # we support PreRequists/SourcesList-$arch sections here too
  1341.         # 
  1342.         # logic for mirror finding works list this:     
  1343.         # - use the mirror template from the config, then: [done]
  1344.         # 
  1345.         #  - try to find known mirror (isMirror) and prepend it [done]
  1346.         #  - archive.ubuntu.com is always a fallback at the end [done]
  1347.         # 
  1348.         # see if we find backports with that
  1349.         # - if not, try guessing based on URI, Trust and Dist   [done]
  1350.         #   in existing sources.list (internal mirror with no
  1351.         #   outside connection maybe)
  1352.         # 
  1353.         # make sure to remove file on cancel
  1354.         
  1355.         # FIXME: use the DistUpgradeFetcherCore logic
  1356.         #        in mirror_from_sources_list() here
  1357.         #        (and factor that code out into a helper)
  1358.  
  1359.         conf_option = "SourcesList"
  1360.         if self.config.has_option("PreRequists",conf_option+"-%s" % self.arch):
  1361.             conf_option = conf_option + "-%s" % self.arch
  1362.         prereq_template = self.config.get("PreRequists",conf_option)
  1363.         if not os.path.exists(prereq_template):
  1364.             logging.error("sourceslist not found '%s'" % prereq_template)
  1365.             return False
  1366.         outpath = os.path.join(apt_pkg.Config.FindDir("Dir::Etc::sourceparts"), prereq_template)
  1367.         outfile = os.path.join(apt_pkg.Config.FindDir("Dir::Etc::sourceparts"), prereq_template)
  1368.         self._addPreRequistsSourcesList(prereq_template, outfile) 
  1369.         try:
  1370.             self._verifyBackports()
  1371.         except NoBackportsFoundException, e:
  1372.             self._addPreRequistsSourcesList(prereq_template, outfile, dumb=True) 
  1373.             try:
  1374.                 self._verifyBackports()
  1375.             except NoBackportsFoundException, e:
  1376.                 logging.warning("no backport for '%s' found" % e)
  1377.             return False
  1378.         
  1379.         # save cachedir and setup new one
  1380.         cachedir = apt_pkg.Config.Find("Dir::Cache::archives")
  1381.         cwd = os.getcwd()
  1382.         if not os.path.exists(os.path.join(backportsdir,"partial")):
  1383.             os.mkdir(os.path.join(backportsdir,"partial"))
  1384.         os.chdir(backportsdir)
  1385.         apt_pkg.Config.Set("Dir::Cache::archives",backportsdir)
  1386.  
  1387.         # FIXME: sanity check the origin (just for safety)
  1388.         for pkgname in backportslist:
  1389.             pkg = self.cache[pkgname]
  1390.             # look for the right version (backport)
  1391.             ver = self.cache._depcache.GetCandidateVer(pkg._pkg)
  1392.             if not ver:
  1393.                 logging.error("No candidate for '%s'" % pkgname)
  1394.                 os.unlink(outpath)
  1395.                 return False
  1396.             if ver.FileList == None:
  1397.                 logging.error("No ver.FileList for '%s'" % pkgname)
  1398.                 os.unlink(outpath)
  1399.                 return False
  1400.             logging.debug("marking '%s' for install" % pkgname)
  1401.             # mvo: autoInst is not available on dapper
  1402.             #pkg.markInstall(autoInst=False, autoFix=False)
  1403.             pkg.markInstall(autoFix=False)
  1404.  
  1405.         # mark the backports for upgrade and get them
  1406.         fetcher = apt_pkg.GetAcquire(self._view.getFetchProgress())
  1407.         pm = apt_pkg.GetPackageManager(self.cache._depcache)
  1408.  
  1409.         # now get it
  1410.         try:
  1411.             res = True
  1412.             self.cache._fetchArchives(fetcher, pm)
  1413.         except IOError, e:
  1414.             logging.error("_fetchArchives returned '%s'" % e)
  1415.             res = False
  1416.  
  1417.         if res == False:
  1418.             logging.warning("_fetchArchives for backports returned False")
  1419.  
  1420.         # reset the cache dir
  1421.         os.unlink(outpath)
  1422.         apt_pkg.Config.Set("Dir::Cache::archives",cachedir)
  1423.         os.chdir(cwd)
  1424.         return self.setupRequiredBackports(backportsdir)
  1425.  
  1426.     def setupRequiredBackports(self, backportsdir):
  1427.         " setup the required backports in a evil way "
  1428.         if not glob.glob(backportsdir+"/*.udeb"):
  1429.             logging.error("no backports found in setupRequiredBackports()")
  1430.             return False
  1431.         # unpack the backports first
  1432.         for deb in glob.glob(backportsdir+"/*.udeb"):
  1433.             logging.debug("extracting udeb '%s' " % deb)
  1434.             if os.system("dpkg-deb -x %s %s" % (deb, backportsdir)) != 0:
  1435.                 return False
  1436.         # setup some paths to make sure the new stuff is used
  1437.         os.environ["LD_LIBRARY_PATH"] = backportsdir+"/usr/lib"
  1438.         os.environ["PYTHONPATH"] = backportsdir+"/usr/lib/python%s.%s/site-packages/" % (sys.version_info[0], sys.version_info[1])
  1439.         os.environ["PATH"] = "%s:%s" % (backportsdir+"/usr/bin",
  1440.                                         os.environ["PATH"])
  1441.         # copy log so that it gets not overwritten
  1442.         logging.shutdown()
  1443.         shutil.copy("/var/log/dist-upgrade/main.log",
  1444.                     "/var/log/dist-upgrade/main_pre_req.log")
  1445.         # now exec self again
  1446.         args = sys.argv + ["--have-prerequists"]
  1447.         if self.useNetwork:
  1448.             args.append("--with-network")
  1449.         else:
  1450.             args.append("--without-network")
  1451.         # work around kde being clever and removing the x bit
  1452.         check_and_fix_xbit(sys.argv[0])
  1453.         os.execve(sys.argv[0],args, os.environ)
  1454.  
  1455.     # this is the core
  1456.     def fullUpgrade(self):
  1457.         # sanity check (check for ubuntu-desktop, brokenCache etc)
  1458.         self._view.updateStatus(_("Checking package manager"))
  1459.         self._view.setStep(DistUpgradeView.STEP_PREPARE)
  1460.  
  1461.         if not self.prepare():
  1462.             logging.error("self.prepared() failed")
  1463.             self._view.error(_("Preparing the upgrade failed"),
  1464.                              _("Preparing the system for the upgrade "
  1465.                                "failed. Please report this as a bug "
  1466.                                "against the 'update-manager' "
  1467.                                "package and include the files in "
  1468.                                "/var/log/dist-upgrade/ "
  1469.                                "in the bug report." ))
  1470.             sys.exit(1)
  1471.  
  1472.         # mvo: commented out for now, see #54234, this needs to be
  1473.         #      refactored to use a arch=any tarball
  1474.         if (self.config.has_section("PreRequists") and
  1475.             self.options and
  1476.             self.options.havePrerequists == False):
  1477.             logging.debug("need backports")
  1478.             # get backported packages (if needed)
  1479.             if not self.getRequiredBackports():
  1480.                 self._view.error(_("Getting upgrade prerequisites failed"),
  1481.                                  _("The system was unable to get the "
  1482.                                    "prerequisites for the upgrade. "
  1483.                                    "The upgrade will abort now and restore "
  1484.                                    "the original system state.\n"
  1485.                                    "\n"
  1486.                                    "Please report this as a bug "
  1487.                                    "against the 'update-manager' "
  1488.                                    "package and include the files in "
  1489.                                    "/var/log/dist-upgrade/ "
  1490.                                    "in the bug report." ))
  1491.                 self.abort()
  1492.  
  1493.         # run a "apt-get update" now, its ok to ignore errors, 
  1494.         # because 
  1495.         # a) we disable any third party sources later
  1496.         # b) we check if we have valid ubuntu sources later
  1497.         #    after we rewrite the sources.list and do a 
  1498.         #    apt-get update there too
  1499.         # because the (unmodified) sources.list of the user
  1500.         # may contain bad/unreachable entries we run only
  1501.         # with a single retry
  1502.         self.doUpdate(showErrors=False, forceRetries=1)
  1503.         self.openCache()
  1504.  
  1505.         # do pre-upgrade stuff (calc list of obsolete pkgs etc)
  1506.         if not self.doPostInitialUpdate():
  1507.             self.abort()
  1508.  
  1509.         # update sources.list
  1510.         self._view.setStep(DistUpgradeView.STEP_MODIFY_SOURCES)
  1511.         self._view.updateStatus(_("Updating repository information"))
  1512.         if not self.updateSourcesList():
  1513.             self.abort()
  1514.  
  1515.         # add cdrom (if we have one)
  1516.         if (self.aptcdrom and
  1517.             not self.aptcdrom.add(self.sources_backup_ext)):
  1518.             sys.exit(1)
  1519.  
  1520.         # then update the package index files
  1521.         if not self.doUpdate():
  1522.             self.abort()
  1523.  
  1524.         # then open the cache (again)
  1525.         self._view.updateStatus(_("Checking package manager"))
  1526.         self.openCache()
  1527.         # now check if we still have some key packages available/downloadable
  1528.         # after the update - if not something went seriously wrong
  1529.         # (this happend e.g. during the intrepid->jaunty upgrade for some
  1530.         #  users when de.archive.ubuntu.com was overloaded)
  1531.         for pkg in self.config.getlist("Distro","BaseMetaPkgs"):
  1532.             if (not self.cache.has_key(pkg) or
  1533.                 not self.cache.anyVersionDownloadable(self.cache[pkg])):
  1534.                 # FIXME: we could offer to add default source entries here,
  1535.                 #        but we need to be careful to not duplicate them
  1536.                 #        (i.e. the error here could be something else than
  1537.                 #        missing sources entries but network errors etc)
  1538.                 logging.error("No '%s' available/downloadable after sources.list rewrite+update" % pkg) 
  1539.                 self._view.error(_("Invalid package information"),
  1540.                                  _("After your package information was "
  1541.                                    "updated the essential package '%s' can "
  1542.                                    "not be found anymore.\n"
  1543.                                    "This indicates a serious error, please "
  1544.                                    "report this bug against the 'update-manager' "
  1545.                                    "package and include the files in /var/log/dist-upgrade/ "
  1546.                                    "in the bug report.") % pkg)
  1547.                 self.abort()
  1548.  
  1549.         # calc the dist-upgrade and see if the removals are ok/expected
  1550.         # do the dist-upgrade
  1551.         self._view.updateStatus(_("Calculating the changes"))
  1552.         if not self.askDistUpgrade():
  1553.             self.abort()
  1554.  
  1555.         # fetch the stuff
  1556.         self._view.setStep(DistUpgradeView.STEP_FETCH)
  1557.         self._view.updateStatus(_("Fetching"))
  1558.         if not self.doDistUpgradeFetching():
  1559.             self.abort()
  1560.  
  1561.         # now do the upgrade
  1562.         self._view.setStep(DistUpgradeView.STEP_INSTALL)
  1563.         self._view.updateStatus(_("Upgrading"))
  1564.         if not self.doDistUpgrade():
  1565.             # run the post install scripts (for stuff like UUID conversion)
  1566.             self.runPostInstallScripts()
  1567.             # don't abort here, because it would restore the sources.list
  1568.             self._view.information(_("Upgrade complete"),
  1569.                                    _("The upgrade is completed but there "
  1570.                                      "were errors during the upgrade "
  1571.                                      "process."))
  1572.             sys.exit(1) 
  1573.             
  1574.         # do post-upgrade stuff
  1575.         self._view.setStep(DistUpgradeView.STEP_CLEANUP)
  1576.         self._view.updateStatus(_("Searching for obsolete software"))
  1577.         self.doPostUpgrade()
  1578.  
  1579.         # done, ask for reboot
  1580.         self._view.setStep(DistUpgradeView.STEP_REBOOT)
  1581.         self._view.updateStatus(_("System upgrade is complete."))            
  1582.         # FIXME should we look into /var/run/reboot-required here?
  1583.         if self._view.confirmRestart():
  1584.             p = subprocess.Popen("/sbin/reboot")
  1585.             sys.exit(0)
  1586.         return True
  1587.         
  1588.     def run(self):
  1589.         self._view.processEvents()
  1590.         return self.fullUpgrade()
  1591.     
  1592.     def doPartialUpgrade(self):
  1593.         " partial upgrade mode, useful for repairing "
  1594.         from DistUpgrade.DistUpgradeView import STEP_PREPARE, STEP_MODIFY_SOURCES, STEP_FETCH, STEP_INSTALL, STEP_CLEANUP, STEP_REBOOT
  1595.         self._view.setStep(STEP_PREPARE)
  1596.         self._view.hideStep(STEP_MODIFY_SOURCES)
  1597.         self._view.hideStep(STEP_REBOOT)
  1598.         self._partialUpgrade = True
  1599.         self.prepare()
  1600.         if not self.doPostInitialUpdate():
  1601.             return False
  1602.         if not self.askDistUpgrade():
  1603.             return False
  1604.         self._view.setStep(STEP_FETCH)
  1605.         self._view.updateStatus(_("Fetching"))
  1606.         if not self.doDistUpgradeFetching():
  1607.             return False
  1608.         self._view.setStep(STEP_INSTALL)
  1609.         self._view.updateStatus(_("Upgrading"))
  1610.         if not self.doDistUpgrade():
  1611.             self._view.information(_("Upgrade complete"),
  1612.                                    _("The upgrade is completed but there "
  1613.                                      "were errors during the upgrade "
  1614.                                      "process."))
  1615.             return False
  1616.         self._view.setStep(STEP_CLEANUP)
  1617.         if not self.doPostUpgrade():
  1618.             self._view.information(_("Upgrade complete"),
  1619.                                    _("The upgrade is completed but there "
  1620.                                      "were errors during the upgrade "
  1621.                                      "process."))
  1622.             return False
  1623.         self._view.information(_("Upgrade complete"),
  1624.                                _("The partial upgrade was completed."))
  1625.         return True
  1626.  
  1627.  
  1628. if __name__ == "__main__":
  1629.     from DistUpgradeView import DistUpgradeView
  1630.     from DistUpgradeViewText import DistUpgradeViewText
  1631.     from DistUpgradeCache import MyCache
  1632.     logging.basicConfig(level=logging.DEBUG)
  1633.     v = DistUpgradeViewText()
  1634.     dc = DistUpgradeController(v)
  1635.     #dc.openCache()
  1636.     dc._disableAptCronJob()
  1637.     dc._enableAptCronJob()
  1638.     #dc._addRelatimeToFstab()
  1639.     #dc.prepare()
  1640.     #dc.askDistUpgrade()
  1641.     #dc._checkFreeSpace()
  1642.     #dc._rewriteFstab()
  1643.     #dc._checkAdminGroup()
  1644.     #dc._rewriteAptPeriodic(2)
  1645.